{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Developing, Training, and Deploying a TensorFlow model on Vertex AI\n",
    "\n",
    "In this notebook, we will develop a Keras model to predict flight delays using TensorFlow 2.0 as the backend."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensorflow version 2.6.0\n",
      "project: ai-analytics-solutions bucket: ai-analytics-solutions-dsongcp\n"
     ]
    }
   ],
   "source": [
    "import os, json, math, shutil\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "print(\"Tensorflow version \" + tf.__version__)\n",
    "\n",
    "# environment variables used by bash cells\n",
    "PROJECT=!(gcloud config get-value project)\n",
    "PROJECT=PROJECT[0]\n",
    "\n",
    "###### CHANGE AS NEEDED\n",
    "REGION = 'us-central1'\n",
    "BUCKET='{}-dsongcp'.format(PROJECT)\n",
    "os.environ['ENDPOINT_NAME'] = 'flights'\n",
    "######\n",
    "\n",
    "os.environ['BUCKET'] = BUCKET\n",
    "os.environ['REGION'] = REGION\n",
    "os.environ['TF_VERSION']='2-' + tf.__version__[2:3]  # needed to choose container\n",
    "print(\"project:\", PROJECT, \"bucket:\", BUCKET)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export files that contain training, validation data\n",
    "\n",
    "The training and validation dataset requires doing a join on several BigQuery tables. Because of this,\n",
    "we'll need export the data we need to create new tables that are flattened (the BigQueryReader in\n",
    "TensorFlow needs tables: see https://towardsdatascience.com/how-to-read-bigquery-data-from-tensorflow-2-0-efficiently-9234b69165c8). But if we are going to make a copy of the data, we might as well export the data to\n",
    "Google Cloud Storage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Query complete after 0.01s: 100%|██████████| 4/4 [00:00<00:00, 2441.74query/s]                        \n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: []\n",
       "Index: []"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%bigquery\n",
    "CREATE OR REPLACE TABLE dsongcp.flights_train_data AS\n",
    "\n",
    "SELECT\n",
    "  IF(arr_delay < 15, 1.0, 0.0) AS ontime,\n",
    "  dep_delay,\n",
    "  taxi_out,\n",
    "  distance,\n",
    "  origin,\n",
    "  dest,\n",
    "  EXTRACT(hour FROM dep_time) AS dep_hour,\n",
    "  IF (EXTRACT(dayofweek FROM dep_time) BETWEEN 2 AND 6, 1, 0) AS is_weekday,\n",
    "  UNIQUE_CARRIER AS carrier,\n",
    "  dep_airport_lat,\n",
    "  dep_airport_lon,\n",
    "  arr_airport_lat,\n",
    "  arr_airport_lon\n",
    "FROM dsongcp.flights_tzcorr f\n",
    "JOIN dsongcp.trainday t\n",
    "ON f.FL_DATE = t.FL_DATE\n",
    "WHERE\n",
    "  f.CANCELLED = False AND \n",
    "  f.DIVERTED = False AND\n",
    "  is_train_day = 'True'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Query complete after 0.00s: 100%|██████████| 4/4 [00:00<00:00, 2111.40query/s]                        \n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: []\n",
       "Index: []"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%bigquery\n",
    "CREATE OR REPLACE TABLE dsongcp.flights_eval_data AS\n",
    "\n",
    "SELECT\n",
    "  IF(arr_delay < 15, 1.0, 0.0) AS ontime,\n",
    "  dep_delay,\n",
    "  taxi_out,\n",
    "  distance,\n",
    "  origin,\n",
    "  dest,\n",
    "  EXTRACT(hour FROM dep_time) AS dep_hour,\n",
    "  IF (EXTRACT(dayofweek FROM dep_time) BETWEEN 2 AND 6, 1, 0) AS is_weekday,\n",
    "  UNIQUE_CARRIER AS carrier,\n",
    "  dep_airport_lat,\n",
    "  dep_airport_lon,\n",
    "  arr_airport_lat,\n",
    "  arr_airport_lon\n",
    "FROM dsongcp.flights_tzcorr f\n",
    "JOIN dsongcp.trainday t\n",
    "ON f.FL_DATE = t.FL_DATE\n",
    "WHERE\n",
    "  f.CANCELLED = False AND \n",
    "  f.DIVERTED = False AND\n",
    "  is_train_day = 'False'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Query complete after 0.00s: 100%|██████████| 4/4 [00:00<00:00, 2163.96query/s]                        \n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: []\n",
       "Index: []"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%bigquery\n",
    "CREATE OR REPLACE TABLE dsongcp.flights_all_data AS\n",
    "\n",
    "SELECT\n",
    "  IF(arr_delay < 15, 1.0, 0.0) AS ontime,\n",
    "  dep_delay,\n",
    "  taxi_out,\n",
    "  distance,\n",
    "  origin,\n",
    "  dest,\n",
    "  EXTRACT(hour FROM dep_time) AS dep_hour,\n",
    "  IF (EXTRACT(dayofweek FROM dep_time) BETWEEN 2 AND 6, 1, 0) AS is_weekday,\n",
    "  UNIQUE_CARRIER AS carrier,\n",
    "  dep_airport_lat,\n",
    "  dep_airport_lon,\n",
    "  arr_airport_lat,\n",
    "  arr_airport_lon,\n",
    "  IF (is_train_day = 'True',\n",
    "      IF(ABS(MOD(FARM_FINGERPRINT(CAST(f.FL_DATE AS STRING)), 100)) < 60, 'TRAIN', 'VALIDATE'),\n",
    "      'TEST') AS data_split\n",
    "FROM dsongcp.flights_tzcorr f\n",
    "JOIN dsongcp.trainday t\n",
    "ON f.FL_DATE = t.FL_DATE\n",
    "WHERE\n",
    "  f.CANCELLED = False AND \n",
    "  f.DIVERTED = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exporting dsongcp.flights_train_data to gs://ai-analytics-solutions-dsongcp/ch9/data/train.csv and deleting table\n",
      "BigQuery error in extract operation: Error processing job 'ai-analytics-\n",
      "solutions:bqjob_r44fc378e3cfd5471_0000017ce851056f_1': Not found: Table ai-\n",
      "analytics-solutions:dsongcp.flights_train_data was not found in location US\n",
      "Exporting dsongcp.flights_eval_data to gs://ai-analytics-solutions-dsongcp/ch9/data/eval.csv and deleting table\n",
      "BigQuery error in extract operation: Error processing job 'ai-analytics-\n",
      "solutions:bqjob_r636cd98e538171f2_0000017ce8510e6d_1': Not found: Table ai-\n",
      "analytics-solutions:dsongcp.flights_eval_data was not found in location US\n",
      "Exporting dsongcp.flights_all_data to gs://ai-analytics-solutions-dsongcp/ch9/data/all.csv and deleting table\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Waiting on bqjob_r3b5206a10b46f1bf_0000017ce851171e_1 ... (108s) Current status: DONE   \n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "PROJECT=$(gcloud config get-value project)\n",
    "for dataset in \"train\" \"eval\" \"all\"; do\n",
    "  TABLE=dsongcp.flights_${dataset}_data\n",
    "  CSV=gs://${BUCKET}/ch9/data/${dataset}.csv\n",
    "  echo \"Exporting ${TABLE} to ${CSV} and deleting table\"\n",
    "  bq --project_id=${PROJECT} extract --destination_format=CSV $TABLE $CSV\n",
    "  bq --project_id=${PROJECT} rm -f $TABLE\n",
    "done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "445.01 MiB  2021-11-04T00:21:29Z  gs://ai-analytics-solutions-dsongcp/ch9/data/all.csv\n",
      "115.19 MiB  2021-11-02T06:34:16Z  gs://ai-analytics-solutions-dsongcp/ch9/data/eval.csv\n",
      "296.96 MiB  2021-11-02T06:33:38Z  gs://ai-analytics-solutions-dsongcp/ch9/data/train.csv\n",
      "TOTAL: 3 objects, 898801258 bytes (857.16 MiB)\n"
     ]
    }
   ],
   "source": [
    "!gsutil ls -lh gs://{BUCKET}/ch9/data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup in notebook\n",
    "\n",
    "For development purposes, we'll train for just a few epochs.\n",
    "That's why the NUM_EXAMPLES is so low."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "DEVELOP_MODE = True\n",
    "NUM_EXAMPLES = 5000*1000 # doesn't need to be precise but get order of magnitude right."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use wildcard in the name so that it works even if you have multiple files\n",
    "training_data_uri = 'gs://{}/ch9/data/train*'.format(BUCKET)\n",
    "validation_data_uri = 'gs://{}/ch9/data/eval*'.format(BUCKET)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": [
     "parameters"
    ]
   },
   "outputs": [],
   "source": [
    "NBUCKETS = 5 #\n",
    "NEMBEDS = 3\n",
    "TRAIN_BATCH_SIZE = 64\n",
    "DNN_HIDDEN_UNITS = '64,32'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating the input data pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-15 07:36:27.640989: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcuda.so.1'; dlerror: libcuda.so.1: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /usr/local/cuda/lib64:/usr/local/cuda/lib:/usr/local/lib/x86_64-linux-gnu:/usr/local/nvidia/lib:/usr/local/nvidia/lib64:/usr/local/nvidia/lib:/usr/local/nvidia/lib64\n",
      "2021-11-15 07:36:27.641094: W tensorflow/stream_executor/cuda/cuda_driver.cc:269] failed call to cuInit: UNKNOWN ERROR (303)\n",
      "2021-11-15 07:36:27.641134: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:156] kernel driver does not appear to be running on this host (vm-d0143097-43fe-4d6c-888f-8961b0fba732): /proc/driver/nvidia/version does not exist\n",
      "2021-11-15 07:36:27.687098: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2021-11-15 07:36:29.550755: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 {'ontime': array([1, 1, 0, 1, 1], dtype=int32), 'dep_delay': array([-11,  -8,  11,  -3, -10], dtype=int32), 'taxi_out': array([10, 16, 26,  9, 10], dtype=int32), 'distance': array([ 399,  399, 1056,  201,  261], dtype=int32), 'origin': array([b'ANC', b'BET', b'PBI', b'OGG', b'ANC'], dtype=object), 'dest': array([b'BET', b'ANC', b'HPN', b'LIH', b'FAI'], dtype=object), 'dep_hour': array([19,  5,  0,  4,  6], dtype=int32), 'is_weekday': array([1, 1, 0, 1, 1], dtype=int32), 'carrier': array([b'AS', b'AS', b'B6', b'HA', b'AS'], dtype=object), 'dep_airport_lat': array([61.174168, 60.77861 , 26.683056, 20.898611, 61.174168],\n",
      "      dtype=float32), 'dep_airport_lon': array([-149.99806, -161.83722,  -80.09556, -156.43056, -149.99806],\n",
      "      dtype=float32), 'arr_airport_lat': array([60.77861 , 61.174168, 41.066944, 21.97611 , 64.815   ],\n",
      "      dtype=float32), 'arr_airport_lon': array([-161.83722, -149.99806,  -73.7075 , -159.33888, -147.85638],\n",
      "      dtype=float32)}\n",
      "1 {'ontime': array([1, 1, 1, 1, 1], dtype=int32), 'dep_delay': array([ -5, -13,  -7,  -8,  29], dtype=int32), 'taxi_out': array([14, 13,  9, 12,  9], dtype=int32), 'distance': array([879, 627, 466, 160, 261], dtype=int32), 'origin': array([b'RSW', b'ANC', b'ACY', b'ANC', b'FAI'], dtype=object), 'dest': array([b'CVG', b'SCC', b'MYR', b'CDV', b'ANC'], dtype=object), 'dep_hour': array([14, 22, 11, 23, 15], dtype=int32), 'is_weekday': array([0, 1, 0, 0, 1], dtype=int32), 'carrier': array([b'DL', b'AS', b'NK', b'AS', b'AS'], dtype=object), 'dep_airport_lat': array([26.536112, 61.174168, 39.4575  , 61.174168, 64.815   ],\n",
      "      dtype=float32), 'dep_airport_lon': array([ -81.75528 , -149.99806 ,  -74.577225, -149.99806 , -147.85638 ],\n",
      "      dtype=float32), 'arr_airport_lat': array([39.04889 , 70.19556 , 33.67972 , 60.491665, 61.174168],\n",
      "      dtype=float32), 'arr_airport_lon': array([ -84.66778, -148.46584,  -78.92834, -145.4775 , -149.99806],\n",
      "      dtype=float32)}\n"
     ]
    }
   ],
   "source": [
    "if DEVELOP_MODE:\n",
    "    train_df = tf.data.experimental.make_csv_dataset(training_data_uri, batch_size=5)\n",
    "    for n, data in enumerate(train_df):\n",
    "        numpy_data = {k: v.numpy() for k, v in data.items()} # .numpy() works only in eager mode\n",
    "        print(n, numpy_data)\n",
    "        if n==1: break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Checking input pipeline\n",
      "[(OrderedDict([('dep_delay', <tf.Tensor: shape=(2,), dtype=int32, numpy=array([-2, -6], dtype=int32)>), ('taxi_out', <tf.Tensor: shape=(2,), dtype=int32, numpy=array([13, 10], dtype=int32)>), ('distance', <tf.Tensor: shape=(2,), dtype=int32, numpy=array([539, 466], dtype=int32)>), ('origin', <tf.Tensor: shape=(2,), dtype=string, numpy=array([b'ANC', b'ACY'], dtype=object)>), ('dest', <tf.Tensor: shape=(2,), dtype=string, numpy=array([b'OME', b'MYR'], dtype=object)>), ('dep_hour', <tf.Tensor: shape=(2,), dtype=int32, numpy=array([18, 10], dtype=int32)>), ('is_weekday', <tf.Tensor: shape=(2,), dtype=int32, numpy=array([1, 1], dtype=int32)>), ('carrier', <tf.Tensor: shape=(2,), dtype=string, numpy=array([b'AS', b'NK'], dtype=object)>), ('dep_airport_lat', <tf.Tensor: shape=(2,), dtype=float32, numpy=array([61.174168, 39.4575  ], dtype=float32)>), ('dep_airport_lon', <tf.Tensor: shape=(2,), dtype=float32, numpy=array([-149.99806 ,  -74.577225], dtype=float32)>), ('arr_airport_lat', <tf.Tensor: shape=(2,), dtype=float32, numpy=array([64.5125 , 33.67972], dtype=float32)>), ('arr_airport_lon', <tf.Tensor: shape=(2,), dtype=float32, numpy=array([-165.44444,  -78.92834], dtype=float32)>)]), <tf.Tensor: shape=(2,), dtype=int32, numpy=array([1, 1], dtype=int32)>)]\n"
     ]
    }
   ],
   "source": [
    "def features_and_labels(features):\n",
    "  label = features.pop('ontime') # this is what we will train for\n",
    "  return features, label\n",
    "\n",
    "def read_dataset(pattern, batch_size, mode=tf.estimator.ModeKeys.TRAIN, truncate=None):\n",
    "  dataset = tf.data.experimental.make_csv_dataset(pattern, batch_size, num_epochs=1)\n",
    "  dataset = dataset.map(features_and_labels)\n",
    "  if mode == tf.estimator.ModeKeys.TRAIN:\n",
    "    dataset = dataset.shuffle(batch_size*10)\n",
    "    dataset = dataset.repeat()\n",
    "  dataset = dataset.prefetch(1)\n",
    "  if truncate is not None:\n",
    "    dataset = dataset.take(truncate)\n",
    "  return dataset\n",
    "\n",
    "\n",
    "if DEVELOP_MODE:\n",
    "    print(\"Checking input pipeline\")\n",
    "    one_item = read_dataset(training_data_uri, batch_size=2, truncate=1)\n",
    "    print(list(one_item)) # should print one batch of 2 items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create TensorFlow wide-and-deep model\n",
    "\n",
    "We'll create feature columns, and do some discretization and feature engineering.\n",
    "See the book for details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "real = {\n",
    "    colname : tf.feature_column.numeric_column(colname) \n",
    "          for colname in \n",
    "            (\n",
    "                'dep_delay,taxi_out,distance,dep_hour,is_weekday,' +\n",
    "                'dep_airport_lat,dep_airport_lon,' +\n",
    "                'arr_airport_lat,arr_airport_lon'\n",
    "            ).split(',')\n",
    "}\n",
    "sparse = {\n",
    "      'carrier': tf.feature_column.categorical_column_with_vocabulary_list('carrier',\n",
    "                  vocabulary_list='AS,VX,F9,UA,US,WN,HA,EV,MQ,DL,OO,B6,NK,AA'.split(',')),\n",
    "      'origin' : tf.feature_column.categorical_column_with_hash_bucket('origin', hash_bucket_size=1000),\n",
    "      'dest'   : tf.feature_column.categorical_column_with_hash_bucket('dest', hash_bucket_size=1000),\n",
    "}\n",
    "\n",
    "inputs = {\n",
    "    colname : tf.keras.layers.Input(name=colname, shape=(), dtype='float32') \n",
    "          for colname in real.keys()\n",
    "}\n",
    "inputs.update({\n",
    "    colname : tf.keras.layers.Input(name=colname, shape=(), dtype='string') \n",
    "          for colname in sparse.keys()\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Feature engineering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['carrier', 'origin', 'dest', 'dep_loc', 'arr_loc', 'dep_arr'])\n",
      "dict_keys(['dep_delay', 'taxi_out', 'distance', 'dep_hour', 'is_weekday', 'dep_airport_lat', 'dep_airport_lon', 'arr_airport_lat', 'arr_airport_lon', 'embed_carrier', 'embed_origin', 'embed_dest', 'embed_dep_loc', 'embed_arr_loc', 'embed_dep_arr'])\n"
     ]
    }
   ],
   "source": [
    "latbuckets = np.linspace(20.0, 50.0, NBUCKETS).tolist()  # USA\n",
    "lonbuckets = np.linspace(-120.0, -70.0, NBUCKETS).tolist() # USA\n",
    "disc = {}\n",
    "disc.update({\n",
    "       'd_{}'.format(key) : tf.feature_column.bucketized_column(real[key], latbuckets) \n",
    "          for key in ['dep_airport_lat', 'arr_airport_lat']\n",
    "})\n",
    "disc.update({\n",
    "       'd_{}'.format(key) : tf.feature_column.bucketized_column(real[key], lonbuckets) \n",
    "          for key in ['dep_airport_lon', 'arr_airport_lon']\n",
    "})\n",
    "\n",
    "# cross columns that make sense in combination\n",
    "sparse['dep_loc'] = tf.feature_column.crossed_column(\n",
    "    [disc['d_dep_airport_lat'], disc['d_dep_airport_lon']], NBUCKETS*NBUCKETS)\n",
    "sparse['arr_loc'] = tf.feature_column.crossed_column(\n",
    "    [disc['d_arr_airport_lat'], disc['d_arr_airport_lon']], NBUCKETS*NBUCKETS)\n",
    "sparse['dep_arr'] = tf.feature_column.crossed_column([sparse['dep_loc'], sparse['arr_loc']], NBUCKETS ** 4)\n",
    "\n",
    "# embed all the sparse columns\n",
    "embed = {\n",
    "       'embed_{}'.format(colname) : tf.feature_column.embedding_column(col, NEMBEDS)\n",
    "          for colname, col in sparse.items()\n",
    "}\n",
    "real.update(embed)\n",
    "\n",
    "# one-hot encode the sparse columns\n",
    "sparse = {\n",
    "    colname : tf.feature_column.indicator_column(col)\n",
    "          for colname, col in sparse.items()\n",
    "}\n",
    "\n",
    "if DEVELOP_MODE:\n",
    "    print(sparse.keys())\n",
    "    print(real.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train the model and evaluate once in a while\n",
    "\n",
    "Also checkpoint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing trained model to gs://ai-analytics-solutions-dsongcp/ch9/trained_model\n"
     ]
    }
   ],
   "source": [
    "output_dir='gs://{}/ch9/trained_model'.format(BUCKET)\n",
    "os.environ['OUTDIR'] = output_dir  # needed for deployment\n",
    "print('Writing trained model to {}'.format(output_dir))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/checkpoints/checkpoint#1636605489181015...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/checkpoints/flights.cpt.data-00000-of-00001#1636605486657815...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/checkpoints/flights.cpt.index#1636605487442090...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211102-215550/assets/#1635915365313029...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211102-064013/saved_model.pb#1635835225470277...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/#1635835014526316...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/#1635835220871410...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model//checkpoints/checkpoint#1635915349874921...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211102-215550/#1635915357263146...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211102-064013/variables/variables.data-00000-of-00001#1635835223735388...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model//checkpoints/flights.cpt.data-00000-of-00001#1635915347275808...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211102-064013/#1635835221079623...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211102-064013/variables/#1635835221302106...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model//checkpoints/flights.cpt.index#1635915348152436...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211102-064013/variables/variables.index#1635835224110674...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211102-064013/assets/#1635835224898710...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211102-215550/variables/#1635915357778594...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211102-215550/variables/variables.data-00000-of-00001#1635915362835951...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/checkpoints/#1635835014723911...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211102-215550/saved_model.pb#1635915373130702...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211102-215550/variables/variables.index#1635915363540634...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211110-183336/#1636598085976404...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211110-183336/assets/#1636598093504253...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211110-183336/saved_model.pb#1636598101341372...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211110-183336/variables/#1636598086535216...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211110-183336/variables/variables.data-00000-of-00001#1636598091152179...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211110-183336/variables/variables.index#1636598091805533...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211110-203704/#1636605496113202...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211110-203704/saved_model.pb#1636605511659288...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211110-203704/assets/#1636605503893506...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211110-203704/variables/#1636605496582474...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211110-203704/variables/variables.data-00000-of-00001#1636605501447125...\n",
      "Removing gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211110-203704/variables/variables.index#1636605502146182...\n",
      "/ [33/33 objects] 100% Done                                                     \n",
      "Operation completed over 33 objects.                                             \n"
     ]
    }
   ],
   "source": [
    "!gsutil -m rm -rf $OUTDIR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input tensor:  {'dep_delay': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'dep_delay')>, 'taxi_out': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'taxi_out')>, 'distance': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'distance')>, 'dep_hour': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'dep_hour')>, 'is_weekday': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'is_weekday')>, 'dep_airport_lat': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'dep_airport_lat')>, 'dep_airport_lon': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'dep_airport_lon')>, 'arr_airport_lat': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'arr_airport_lat')>, 'arr_airport_lon': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'arr_airport_lon')>, 'carrier': <KerasTensor: shape=(None,) dtype=string (created by layer 'carrier')>, 'origin': <KerasTensor: shape=(None,) dtype=string (created by layer 'origin')>, 'dest': <KerasTensor: shape=(None,) dtype=string (created by layer 'dest')>}\n",
      "output tensor_name:  pred/Sigmoid:0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Build a wide-and-deep model.\n",
    "def wide_and_deep_classifier(inputs, linear_feature_columns, dnn_feature_columns, dnn_hidden_units):\n",
    "    deep = tf.keras.layers.DenseFeatures(dnn_feature_columns, name='deep_inputs')(inputs)\n",
    "    layers = [int(x) for x in dnn_hidden_units.split(',')]\n",
    "    for layerno, numnodes in enumerate(layers):\n",
    "        deep = tf.keras.layers.Dense(numnodes, activation='relu', name='dnn_{}'.format(layerno+1))(deep)        \n",
    "    wide = tf.keras.layers.DenseFeatures(linear_feature_columns, name='wide_inputs')(inputs)\n",
    "    both = tf.keras.layers.concatenate([deep, wide], name='both')\n",
    "    output = tf.keras.layers.Dense(1, activation='sigmoid', name='pred')(both)\n",
    "    model = tf.keras.Model(inputs, output)\n",
    "    model.compile(optimizer='adam',\n",
    "                  loss='binary_crossentropy',\n",
    "                  metrics=['accuracy'])\n",
    "    return model\n",
    "    \n",
    "model = wide_and_deep_classifier(\n",
    "    inputs,\n",
    "    linear_feature_columns = sparse.values(),\n",
    "    dnn_feature_columns = real.values(),\n",
    "    dnn_hidden_units = DNN_HIDDEN_UNITS)\n",
    "tf.keras.utils.plot_model(model, 'flights_model.png', show_shapes=False, rankdir='LR')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should see:\n",
    "<img src=\"flights_model.png\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2\n",
      "3/3 [==============================] - 12s 3s/step - loss: 4.6574 - accuracy: 0.2656 - val_loss: 1.7522 - val_accuracy: 0.3801\n",
      "\n",
      "Epoch 00001: saving model to gs://ai-analytics-solutions-dsongcp/ch9/trained_model/checkpoints/flights.cpt\n",
      "Epoch 2/2\n",
      "3/3 [==============================] - 5s 2s/step - loss: 1.0390 - accuracy: 0.6406 - val_loss: 0.6351 - val_accuracy: 0.8236\n",
      "\n",
      "Epoch 00002: saving model to gs://ai-analytics-solutions-dsongcp/ch9/trained_model/checkpoints/flights.cpt\n"
     ]
    }
   ],
   "source": [
    "# training and evaluation dataset\n",
    "train_batch_size = TRAIN_BATCH_SIZE\n",
    "if DEVELOP_MODE:\n",
    "    eval_batch_size = 100\n",
    "    steps_per_epoch = 3\n",
    "    epochs = 2\n",
    "    num_eval_examples = eval_batch_size*10\n",
    "else:\n",
    "    eval_batch_size = 100\n",
    "    steps_per_epoch = NUM_EXAMPLES // train_batch_size\n",
    "    epochs = 10\n",
    "    num_eval_examples = eval_batch_size * 100\n",
    "train_dataset = read_dataset(training_data_uri, train_batch_size)\n",
    "eval_dataset = read_dataset(validation_data_uri, eval_batch_size, tf.estimator.ModeKeys.EVAL, num_eval_examples)\n",
    "\n",
    "checkpoint_path = '{}/checkpoints/flights.cpt'.format(output_dir)\n",
    "shutil.rmtree(checkpoint_path, ignore_errors=True)\n",
    "cp_callback = tf.keras.callbacks.ModelCheckpoint(checkpoint_path, \n",
    "                                                 save_weights_only=True,\n",
    "                                                 verbose=1)\n",
    "\n",
    "history = model.fit(train_dataset, \n",
    "                    validation_data=eval_dataset,\n",
    "                    epochs=epochs, \n",
    "                    steps_per_epoch=steps_per_epoch,\n",
    "                    callbacks=[cp_callback])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])\n"
     ]
    }
   ],
   "source": [
    "print(history.history.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "nrows = 1\n",
    "ncols = 2\n",
    "fig = plt.figure(figsize=(10, 5))\n",
    "\n",
    "for idx, key in enumerate(['loss', 'accuracy']):\n",
    "    ax = fig.add_subplot(nrows, ncols, idx+1)\n",
    "    plt.plot(history.history[key])\n",
    "    plt.plot(history.history['val_{}'.format(key)])\n",
    "    plt.title('model {}'.format(key))\n",
    "    plt.ylabel(key)\n",
    "    plt.xlabel('epoch')\n",
    "    plt.legend(['train', 'validation'], loc='upper left');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Export the trained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exporting to gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211115-073932\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-15 07:39:34.953003: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211115-073932/assets\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "export_dir = '{}/export/flights_{}'.format(output_dir, time.strftime(\"%Y%m%d-%H%M%S\"))\n",
    "print('Exporting to {}'.format(export_dir))\n",
    "tf.saved_model.save(model, export_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deploy model to Vertex AI\n",
    "\n",
    "This will take several minutes.  Bash in Jupyter doesn't provide intermediate output.\n",
    "\n",
    "You can check progress by visiting https://console.cloud.google.com/vertex-ai/endpoints\n",
    "and https://console.cloud.google.com/vertex-ai/models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211102-064013/\n",
      "Creating Endpoint for flights-20211102-064051\n",
      "ENDPOINT_ID=793486755440361472\n",
      "MODEL_ID=3935868997391613952\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using endpoint [https://us-central1-aiplatform.googleapis.com/]\n",
      "Using endpoint [https://us-central1-aiplatform.googleapis.com/]\n",
      "Waiting for operation [1674467560977858560]...\n",
      "....................done.\n",
      "Created Vertex AI endpoint: projects/379218021631/locations/us-central1/endpoints/793486755440361472.\n",
      "Using endpoint [https://us-central1-aiplatform.googleapis.com/]\n",
      "Using endpoint [https://us-central1-aiplatform.googleapis.com/]\n",
      "Using endpoint [https://us-central1-aiplatform.googleapis.com/]\n",
      "Waiting for operation [3336295823477571584]...\n",
      "..................done.\n",
      "Using endpoint [https://us-central1-aiplatform.googleapis.com/]\n",
      "Using endpoint [https://us-central1-aiplatform.googleapis.com/]\n",
      "Waiting for operation [4957591689330950144]...\n",
      "............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................done.\n",
      "Deployed a model to the endpoint 793486755440361472. Id of the deployed model: 2339101036930662400.\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "# note TF_VERSION and ENDPOINT_NAME set in 1st cell\n",
    "# TF_VERSION=2-6\n",
    "# ENDPOINT_NAME=flights\n",
    "\n",
    "TIMESTAMP=$(date +%Y%m%d-%H%M%S)\n",
    "MODEL_NAME=${ENDPOINT_NAME}-${TIMESTAMP}\n",
    "EXPORT_PATH=$(gsutil ls ${OUTDIR}/export | tail -1)\n",
    "echo $EXPORT_PATH\n",
    "\n",
    "if [[ $(gcloud ai endpoints list --region=$REGION \\\n",
    "        --format='value(DISPLAY_NAME)' --filter=display_name=${ENDPOINT_NAME}) ]]; then\n",
    "    echo \"Endpoint for $MODEL_NAME already exists\"\n",
    "else\n",
    "    # create model\n",
    "    echo \"Creating Endpoint for $MODEL_NAME\"\n",
    "    gcloud ai endpoints create --region=${REGION} --display-name=${ENDPOINT_NAME}\n",
    "fi\n",
    "\n",
    "ENDPOINT_ID=$(gcloud ai endpoints list --region=$REGION \\\n",
    "              --format='value(ENDPOINT_ID)' --filter=display_name=${ENDPOINT_NAME})\n",
    "echo \"ENDPOINT_ID=$ENDPOINT_ID\"\n",
    "\n",
    "# delete any existing models with this name\n",
    "for MODEL_ID in $(gcloud ai models list --region=$REGION --format='value(MODEL_ID)' --filter=display_name=${MODEL_NAME}); do\n",
    "    echo \"Deleting existing $MODEL_NAME ... $MODEL_ID \"\n",
    "    gcloud ai models delete --region=$REGION $MODEL_ID\n",
    "done\n",
    "\n",
    "# upload model\n",
    "gcloud beta ai models upload --region=$REGION --display-name=$MODEL_NAME \\\n",
    "     --container-image-uri=us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.${TF_VERSION}:latest \\\n",
    "     --artifact-uri=$EXPORT_PATH\n",
    "MODEL_ID=$(gcloud ai models list --region=$REGION --format='value(MODEL_ID)' --filter=display_name=${MODEL_NAME})\n",
    "echo \"MODEL_ID=$MODEL_ID\"\n",
    "\n",
    "# deploy model to endpoint\n",
    "gcloud ai endpoints deploy-model $ENDPOINT_ID \\\n",
    "  --region=$REGION \\\n",
    "  --model=$MODEL_ID \\\n",
    "  --display-name=$MODEL_NAME \\\n",
    "  --machine-type=n1-standard-2 \\\n",
    "  --min-replica-count=1 \\\n",
    "  --max-replica-count=1 \\\n",
    "  --traffic-split=0=100\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting example_input.json\n"
     ]
    }
   ],
   "source": [
    "%%writefile example_input.json\n",
    "{\"instances\": [\n",
    "  {\"dep_hour\": 2, \"is_weekday\": 1, \"dep_delay\": 40, \"taxi_out\": 17, \"distance\": 41, \"carrier\": \"AS\", \"dep_airport_lat\": 58.42527778, \"dep_airport_lon\": -135.7075, \"arr_airport_lat\": 58.35472222, \"arr_airport_lon\": -134.57472222, \"origin\": \"GST\", \"dest\": \"JNU\"},\n",
    "  {\"dep_hour\": 22, \"is_weekday\": 0, \"dep_delay\": -7, \"taxi_out\": 7, \"distance\": 201, \"carrier\": \"HA\", \"dep_airport_lat\": 21.97611111, \"dep_airport_lon\": -159.33888889, \"arr_airport_lat\": 20.89861111, \"arr_airport_lon\": -156.43055556, \"origin\": \"LIH\", \"dest\": \"OGG\"}\n",
    "]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "793486755440361472\n",
      "[[0.228779882], [0.766132474]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using endpoint [https://us-central1-aiplatform.googleapis.com/]\n",
      "Using endpoint [https://us-central1-prediction-aiplatform.googleapis.com/]\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "ENDPOINT_ID=$(gcloud ai endpoints list --region=$REGION \\\n",
    "              --format='value(ENDPOINT_ID)' --filter=display_name=${ENDPOINT_NAME})\n",
    "echo $ENDPOINT_ID\n",
    "gcloud ai endpoints predict $ENDPOINT_ID --region=$REGION --json-request=example_input.json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"predictions\": [\n",
      "    [\n",
      "      0.228779882\n",
      "    ],\n",
      "    [\n",
      "      0.766132474\n",
      "    ]\n",
      "  ],\n",
      "  \"deployedModelId\": \"2339101036930662400\",\n",
      "  \"model\": \"projects/379218021631/locations/us-central1/models/3935868997391613952\",\n",
      "  \"modelDisplayName\": \"flights-20211102-064051\"\n",
      "}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using endpoint [https://us-central1-aiplatform.googleapis.com/]\n",
      "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
      "                                 Dload  Upload   Total   Spent    Left  Speed\n",
      "100   809    0   266  100   543   1773   3620 --:--:-- --:--:-- --:--:--  5393\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "PROJECT=$(gcloud config get-value project)\n",
    "ENDPOINT_ID=$(gcloud ai endpoints list --region=$REGION \\\n",
    "              --format='value(ENDPOINT_ID)' --filter=display_name=${ENDPOINT_NAME})\n",
    "\n",
    "curl -X POST \\\n",
    "  -H \"Authorization: Bearer \"$(gcloud auth application-default print-access-token) \\\n",
    "  -H \"Content-Type: application/json; charset=utf-8\" \\\n",
    "  -d @example_input.json \\\n",
    "  \"https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT}/locations/${REGION}/endpoints/${ENDPOINT_ID}:predict\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Explanations\n",
    "\n",
    "Add explainability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211115-073932/\n",
      "The given SavedModel SignatureDef contains the following input(s):\n",
      "  inputs['arr_airport_lat'] tensor_info:\n",
      "      dtype: DT_FLOAT\n",
      "      shape: (-1)\n",
      "      name: serving_default_arr_airport_lat:0\n",
      "  inputs['arr_airport_lon'] tensor_info:\n",
      "      dtype: DT_FLOAT\n",
      "      shape: (-1)\n",
      "      name: serving_default_arr_airport_lon:0\n",
      "  inputs['carrier'] tensor_info:\n",
      "      dtype: DT_STRING\n",
      "      shape: (-1)\n",
      "      name: serving_default_carrier:0\n",
      "  inputs['dep_airport_lat'] tensor_info:\n",
      "      dtype: DT_FLOAT\n",
      "      shape: (-1)\n",
      "      name: serving_default_dep_airport_lat:0\n",
      "  inputs['dep_airport_lon'] tensor_info:\n",
      "      dtype: DT_FLOAT\n",
      "      shape: (-1)\n",
      "      name: serving_default_dep_airport_lon:0\n",
      "  inputs['dep_delay'] tensor_info:\n",
      "      dtype: DT_FLOAT\n",
      "      shape: (-1)\n",
      "      name: serving_default_dep_delay:0\n",
      "  inputs['dep_hour'] tensor_info:\n",
      "      dtype: DT_FLOAT\n",
      "      shape: (-1)\n",
      "      name: serving_default_dep_hour:0\n",
      "  inputs['dest'] tensor_info:\n",
      "      dtype: DT_STRING\n",
      "      shape: (-1)\n",
      "      name: serving_default_dest:0\n",
      "  inputs['distance'] tensor_info:\n",
      "      dtype: DT_FLOAT\n",
      "      shape: (-1)\n",
      "      name: serving_default_distance:0\n",
      "  inputs['is_weekday'] tensor_info:\n",
      "      dtype: DT_FLOAT\n",
      "      shape: (-1)\n",
      "      name: serving_default_is_weekday:0\n",
      "  inputs['origin'] tensor_info:\n",
      "      dtype: DT_STRING\n",
      "      shape: (-1)\n",
      "      name: serving_default_origin:0\n",
      "  inputs['taxi_out'] tensor_info:\n",
      "      dtype: DT_FLOAT\n",
      "      shape: (-1)\n",
      "      name: serving_default_taxi_out:0\n",
      "The given SavedModel SignatureDef contains the following output(s):\n",
      "  outputs['pred'] tensor_info:\n",
      "      dtype: DT_FLOAT\n",
      "      shape: (-1, 1)\n",
      "      name: StatefulPartitionedCall_2:0\n",
      "Method name is: tensorflow/serving/predict\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "model_dir=$(gsutil ls ${OUTDIR}/export | tail -1)\n",
    "echo $model_dir\n",
    "saved_model_cli show --tag_set serve --signature_def serving_default --dir $model_dir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'inputs': {'dep_delay': {'inputTensorName': 'dep_delay'}, 'taxi_out': {'inputTensorName': 'taxi_out'}, 'distance': {'inputTensorName': 'distance'}, 'dep_hour': {'inputTensorName': 'dep_hour'}, 'is_weekday': {'inputTensorName': 'is_weekday'}, 'dep_airport_lat': {'inputTensorName': 'dep_airport_lat'}, 'dep_airport_lon': {'inputTensorName': 'dep_airport_lon'}, 'arr_airport_lat': {'inputTensorName': 'arr_airport_lat'}, 'arr_airport_lon': {'inputTensorName': 'arr_airport_lon'}, 'carrier': {'inputTensorName': 'carrier'}, 'origin': {'inputTensorName': 'origin'}, 'dest': {'inputTensorName': 'dest'}}, 'outputs': {'pred': {'outputTensorName': 'pred'}}}\n"
     ]
    }
   ],
   "source": [
    "cols = ('dep_delay,taxi_out,distance,dep_hour,is_weekday,' +\n",
    "        'dep_airport_lat,dep_airport_lon,' +\n",
    "        'arr_airport_lat,arr_airport_lon,' +\n",
    "        'carrier,origin,dest')\n",
    "inputs = {x: {\"inputTensorName\": \"{}\".format(x)} \n",
    "        for x in cols.split(',')}\n",
    "expl = {\n",
    "    \"inputs\": inputs,\n",
    "    \"outputs\": {\n",
    "    \"pred\": {\n",
    "      \"outputTensorName\": \"pred\"\n",
    "    }\n",
    "  }\n",
    "}\n",
    "print(expl)\n",
    "with open('explanation-metadata.json', 'w') as ofp:\n",
    "    json.dump(expl, ofp, indent=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"inputs\": {\n",
      "    \"dep_delay\": {\n",
      "      \"inputTensorName\": \"dep_delay\"\n",
      "    },\n",
      "    \"taxi_out\": {\n",
      "      \"inputTensorName\": \"taxi_out\"\n",
      "    },\n",
      "    \"distance\": {\n",
      "      \"inputTensorName\": \"distance\"\n",
      "    },\n",
      "    \"dep_hour\": {\n",
      "      \"inputTensorName\": \"dep_hour\"\n",
      "    },\n",
      "    \"is_weekday\": {\n",
      "      \"inputTensorName\": \"is_weekday\"\n",
      "    },\n",
      "    \"dep_airport_lat\": {\n",
      "      \"inputTensorName\": \"dep_airport_lat\"\n",
      "    },\n",
      "    \"dep_airport_lon\": {\n",
      "      \"inputTensorName\": \"dep_airport_lon\"\n",
      "    },\n",
      "    \"arr_airport_lat\": {\n",
      "      \"inputTensorName\": \"arr_airport_lat\"\n",
      "    },\n",
      "    \"arr_airport_lon\": {\n",
      "      \"inputTensorName\": \"arr_airport_lon\"\n",
      "    },\n",
      "    \"carrier\": {\n",
      "      \"inputTensorName\": \"carrier\"\n",
      "    },\n",
      "    \"origin\": {\n",
      "      \"inputTensorName\": \"origin\"\n",
      "    },\n",
      "    \"dest\": {\n",
      "      \"inputTensorName\": \"dest\"\n",
      "    }\n",
      "  },\n",
      "  \"outputs\": {\n",
      "    \"pred\": {\n",
      "      \"outputTensorName\": \"pred\"\n",
      "    }\n",
      "  }\n",
      "}"
     ]
    }
   ],
   "source": [
    "!cat explanation-metadata.json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211115-073932/\n",
      "gcloud beta ai models upload --region=us-central1 --display-name=flights_xai-20211115-153408 --container-image-uri=us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-6:latest --artifact-uri=gs://ai-analytics-solutions-dsongcp/ch9/trained_model/export/flights_20211115-073932/ --explanation-method=sampled-shapley --explanation-path-count=10 --explanation-metadata-file=explanation-metadata.json\n",
      "MODEL_ID=\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using endpoint [https://us-central1-aiplatform.googleapis.com/]\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "# note TF_VERSION set in 1st cell, but ENDPOINT_NAME is being changed\n",
    "# TF_VERSION=2-6\n",
    "\n",
    "ENDPOINT_NAME=flights_xai\n",
    "\n",
    "TIMESTAMP=$(date +%Y%m%d-%H%M%S)\n",
    "MODEL_NAME=${ENDPOINT_NAME}-${TIMESTAMP}\n",
    "EXPORT_PATH=$(gsutil ls ${OUTDIR}/export | tail -1)\n",
    "echo $EXPORT_PATH\n",
    "\n",
    "if [[ $(gcloud ai endpoints list --region=$REGION \\\n",
    "        --format='value(DISPLAY_NAME)' --filter=display_name=${ENDPOINT_NAME}) ]]; then\n",
    "    echo \"Endpoint for $MODEL_NAME already exists\"\n",
    "else\n",
    "    # create model\n",
    "    echo \"Creating Endpoint for $MODEL_NAME\"\n",
    "    gcloud ai endpoints create --region=${REGION} --display-name=${ENDPOINT_NAME}\n",
    "fi\n",
    "\n",
    "ENDPOINT_ID=$(gcloud ai endpoints list --region=$REGION \\\n",
    "              --format='value(ENDPOINT_ID)' --filter=display_name=${ENDPOINT_NAME})\n",
    "echo \"ENDPOINT_ID=$ENDPOINT_ID\"\n",
    "\n",
    "# delete any existing models with this name\n",
    "for MODEL_ID in $(gcloud ai models list --region=$REGION --format='value(MODEL_ID)' --filter=display_name=${MODEL_NAME}); do\n",
    "    echo \"Deleting existing $MODEL_NAME ... $MODEL_ID \"\n",
    "    gcloud ai models delete --region=$REGION $MODEL_ID\n",
    "done\n",
    "\n",
    "# upload model\n",
    "gcloud beta ai models upload --region=$REGION --display-name=$MODEL_NAME \\\n",
    "     --container-image-uri=us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.${TF_VERSION}:latest \\\n",
    "     --artifact-uri=$EXPORT_PATH \\\n",
    "     --explanation-method=sampled-shapley --explanation-path-count=10 --explanation-metadata-file=explanation-metadata.json\n",
    "MODEL_ID=$(gcloud ai models list --region=$REGION --format='value(MODEL_ID)' --filter=display_name=${MODEL_NAME})\n",
    "echo \"MODEL_ID=$MODEL_ID\"\n",
    "\n",
    "# deploy model to endpoint\n",
    "gcloud ai endpoints deploy-model $ENDPOINT_ID \\\n",
    "  --region=$REGION \\\n",
    "  --model=$MODEL_ID \\\n",
    "  --display-name=$MODEL_NAME \\\n",
    "  --machine-type=n1-standard-2 \\\n",
    "  --min-replica-count=1 \\\n",
    "  --max-replica-count=1 \\\n",
    "  --traffic-split=0=100\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"explanations\": [\n",
      "    {\n",
      "      \"attributions\": [\n",
      "        {\n",
      "          \"baselineOutputValue\": 0.48559775948524475,\n",
      "          \"instanceOutputValue\": 0.98635220527648926,\n",
      "          \"featureAttributions\": {\n",
      "            \"dep_hour\": -0.0019751578569412228,\n",
      "            \"distance\": 0.02608233392238617,\n",
      "            \"origin\": 0.00673377513885498,\n",
      "            \"arr_airport_lat\": 0.065238907933235168,\n",
      "            \"dest\": 0.0031582355499267579,\n",
      "            \"taxi_out\": 0.017888876795768741,\n",
      "            \"is_weekday\": -0.0054439753293991089,\n",
      "            \"dep_airport_lon\": 0.15576429069042211,\n",
      "            \"carrier\": 0.0063359200954437259,\n",
      "            \"arr_airport_lon\": 0.32970959544181822,\n",
      "            \"dep_airport_lat\": -0.070850974321365362,\n",
      "            \"dep_delay\": -0.03188738226890564\n",
      "          },\n",
      "          \"outputIndex\": [\n",
      "            0\n",
      "          ],\n",
      "          \"approximationError\": 0.008536300316499771,\n",
      "          \"outputName\": \"pred\"\n",
      "        }\n",
      "      ]\n",
      "    },\n",
      "    {\n",
      "      \"attributions\": [\n",
      "        {\n",
      "          \"baselineOutputValue\": 0.48559775948524475,\n",
      "          \"instanceOutputValue\": 0.99280351400375366,\n",
      "          \"featureAttributions\": {\n",
      "            \"dep_airport_lon\": 0.058571708202362058,\n",
      "            \"taxi_out\": 0.0054247319698333737,\n",
      "            \"origin\": 0.0043834358453750614,\n",
      "            \"arr_airport_lat\": 0.020084306597709659,\n",
      "            \"carrier\": 0.0024113625288009642,\n",
      "            \"distance\": 0.1248617976903915,\n",
      "            \"is_weekday\": 0,\n",
      "            \"dep_delay\": 0.014246141910552981,\n",
      "            \"dep_airport_lat\": -0.043553626537323,\n",
      "            \"dep_hour\": -0.0071308523416519169,\n",
      "            \"arr_airport_lon\": 0.33086674809455868,\n",
      "            \"dest\": -0.0029599994421005251\n",
      "          },\n",
      "          \"outputIndex\": [\n",
      "            0\n",
      "          ],\n",
      "          \"approximationError\": 0.007621675580783898,\n",
      "          \"outputName\": \"pred\"\n",
      "        }\n",
      "      ]\n",
      "    }\n",
      "  ],\n",
      "  \"deployedModelId\": \"48598413947699200\",\n",
      "  \"predictions\": [\n",
      "    [\n",
      "      0.986352205\n",
      "    ],\n",
      "    [\n",
      "      0.992803574\n",
      "    ]\n",
      "  ]\n",
      "}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using endpoint [https://us-central1-aiplatform.googleapis.com/]\n",
      "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
      "                                 Dload  Upload   Total   Spent    Left  Speed\n",
      "100  2553    0  2010  100   543   8626   2330 --:--:-- --:--:-- --:--:-- 10957\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "PROJECT=$(gcloud config get-value project)\n",
    "ENDPOINT_NAME=flights_xai\n",
    "ENDPOINT_ID=$(gcloud ai endpoints list --region=$REGION \\\n",
    "              --format='value(ENDPOINT_ID)' --filter=display_name=${ENDPOINT_NAME})\n",
    "\n",
    "curl -X POST \\\n",
    "  -H \"Authorization: Bearer \"$(gcloud auth application-default print-access-token) \\\n",
    "  -H \"Content-Type: application/json; charset=utf-8\" \\\n",
    "  -d @example_input.json \\\n",
    "  \"https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT}/locations/${REGION}/endpoints/${ENDPOINT_ID}:explain\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright 2016-2021 Google Inc. Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "environment": {
   "kernel": "conda-root-py",
   "name": "tf2-gpu.2-6.m84",
   "type": "gcloud",
   "uri": "gcr.io/deeplearning-platform-release/tf2-gpu.2-6:m84"
  },
  "kernelspec": {
   "display_name": "Python [conda env:root] *",
   "language": "python",
   "name": "conda-root-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
